home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / Mops 2.7 / Mops source / Asm Source / ic2 < prev    next >
Encoding:
Text File  |  1993-07-25  |  14.1 KB  |  841 lines  |  [TEXT/MSET]
  1. \ IC2 - Build the actual codes and return lengths of the instructions.
  2. \  9/85 RW Split off from instClasses
  3. \  03/06/86  GDC fixed MOVEM (type 20)
  4. \  Aug 86 mrh fixed several more bugs in MOVEM
  5. \  Jul 87 mrh added PUSH, POP
  6. \  Jun 92 mrh fixed move to CCR
  7.  
  8. \ TYPE14 - MOVE instruction
  9. \  the bad one. and I do mean Bad ( Leroy Brown bad )
  10.  
  11.  
  12. : MOVESIZE    \ ( n -- n' )
  13.     SELECT{    0 is{  1  }end
  14.         1 is{  3  }end
  15.         2 is{  2  }end
  16.     DEFAULT{
  17.     }SELECT
  18.     12 <<  ;
  19.  
  20. :CLASS type14 super(  machinst  )
  21.  
  22. :M BUILD:       { \ work flag size -- }
  23.     op1 getOp
  24.     op2 getOp
  25.     true -> flag
  26.     mode: op1 sr-type =
  27.     IF    false -> flag
  28.            sr>-code -> work
  29.            ea: op2 work or w,
  30.     THEN
  31.     mode: op2 sr-type =
  32.     IF    false -> flag
  33.            >sr-code -> work
  34.            ea: op1 work or w,
  35.     THEN
  36.     mode: op1 ccr-type =
  37.     IF    false -> flag
  38.         ccr>-code -> work
  39.         ea: op2 work or w,
  40.     THEN
  41.     mode: op2 ccr-type =
  42.     IF    false -> flag
  43.         >ccr-code -> work
  44.         ea: op1 work or w,
  45.     THEN
  46.     mode: op2 usp-type =
  47.     IF    false -> flag
  48.            usp-code -> work
  49.            reg: op1 work or w,
  50.     THEN
  51.     mode: op1 usp-type =
  52.     IF    false -> flag
  53.         usp-code -> work
  54.         reg: op2 work or -> work
  55.         8 ++> work
  56.         work w,
  57.     THEN
  58.     flag
  59.     IF    get: bytecode
  60.         opFmt  moveSize  or
  61.         reg: op2  9 <<  mode: op2  7 min  6 <<  or  or
  62.         ea: op1  or
  63.         w,
  64.     THEN
  65.     op1 compIdxMode
  66.     op2 compIdxMode
  67. ;M
  68.  
  69. :M LENGTH:
  70.     op1 getOp
  71.     op1 get: srcMask check
  72.     op2 getOp
  73.     op2 get: dstMask check
  74.     mode: op1 usp-type = mode: op2 1 = not and
  75.     mode: op2 usp-type = mode: op1 1 = not and or
  76.     IF  208 asmError  THEN
  77.     op1 modesize  op2 modesize  +  1+
  78. ;M
  79.  
  80. ;CLASS
  81.  
  82. \ TYPE15 - MOVEQ. e.g. MOVEQ
  83. :CLASS type15 super(  machinst  )
  84.  
  85. :M BUILD:       { \ work -- }
  86.     op1 getOp
  87.     op2 getOp
  88.     get: bytecode
  89.     value: op1  249 byteChk  or
  90.     reg: op2 9 << or  w,
  91. ;M
  92.  
  93. :M LENGTH:      ( -- len )
  94.     op1 getOp
  95.     op1 get: srcMask check
  96.     op2 getOp
  97.     op2 get: dstMask check
  98.     1
  99. ;M
  100.  
  101. ;CLASS
  102.  
  103. \ TYPE16 - TRAP, e.g. TRAP #12
  104. :CLASS type16 super(  machinst  )
  105.  
  106. :M BUILD:
  107.     op1 getOp
  108.     get: bytecode
  109.     value: op1 15 min 0 max or  w,
  110. ;M
  111.  
  112. :M LENGTH:
  113.     op1 getOp
  114.     op1 get: srcMask check
  115.     1
  116. ;M
  117.  
  118. ;CLASS
  119.  
  120. \ TYPE18 - MOVEP
  121. :CLASS type18 super(  machinst  )
  122.  
  123. :M LENGTH:       ( -- len )
  124.     op1 getOp
  125.     op1 get: srcMask check
  126.     op2 getOp
  127.     op2 get: dstMask check
  128.     1
  129.     op1 modesize +
  130.     op2 modesize +
  131. ;M
  132.  
  133. :M BUILD:     { \ work mode dreg areg aOp -- }
  134.     op1 getOp
  135.     op2 getOp
  136.     mode: op1 0=
  137.     IF
  138.         opFmt 2 =
  139.         IF
  140.                7 -> mode
  141.         ELSE
  142.                6 -> mode
  143.         THEN
  144.            reg: op1 -> dreg
  145.         reg: op2 -> areg
  146.         op2 -> aOp
  147.     ELSE
  148.         opFmt 2 =
  149.         IF
  150.             5 -> mode
  151.         ELSE
  152.             4 -> mode
  153.         THEN
  154.         reg: op2 -> dreg
  155.         reg: op1 -> areg
  156.         op1 -> aOp
  157.     THEN
  158.     get: bytecode -> work
  159.     dreg 9 << work or -> work
  160.     mode 6 << work or -> work
  161.     areg work or -> work
  162.     work w,
  163.     aOp compidxmode
  164. ;M
  165.  
  166. ;CLASS
  167.  
  168. \ TYPE19 - DBcc, etc.
  169. :CLASS type19 super(  machinst  )
  170.  
  171. :M BUILD:
  172.     op1 getOp
  173.     op2 getOp
  174.     get: bytecode
  175.     reg: op1 or  w,
  176.     op2 abs: operand  here -  248 wordChk  w,
  177. ;M
  178.  
  179. :M LENGTH:
  180.     op1 getOp
  181.     op1 get: srcMask check
  182.     op2 getOp
  183.     op2 get: dstMask check
  184.     2
  185. ;M
  186.  
  187. ;CLASS
  188.  
  189. \ TYPE20 - MOVEM
  190. :CLASS type20 super(  machinst  )
  191.  
  192. :M BUILD:    { \ opDesc regMask drFlag -- }
  193.     msg" build moveMsg"
  194.     op1 getOp
  195.     mode: op1 0=  mode: op1  1 =  or
  196.     IF            \ register list in operand 1
  197.         msg" exec IF"
  198.         op1 false buildRegMask -> regMask
  199.                 \ make register mask. Flag always 1.
  200.         op2 getOp
  201.         0 -> drFlag
  202.         ea: op2
  203.     ELSE            \ register list in operand 2
  204.         msg" exec ELSE"
  205.         1 -> drFlag
  206.         nextToken drop
  207.         op2 getOp
  208.         op2 false buildRegMask -> regMask
  209.         ea: op1
  210.     THEN
  211.     ( ea in stack )  get: bytecode  or
  212.     drFlag 10 << or
  213.     opFmt 1 max 1- 6 << or  w,
  214.     regMask
  215.     mode: op2 4 = IF  revMask  THEN        \ Reverse mask if predecrement
  216.     val" regmask is " w,
  217.     op1 compidxmode
  218.     op2 compidxmode
  219. ;M
  220.  
  221. :M LENGTH:   { \ len -- len }
  222.     2 -> len
  223.     op1 getop
  224.     mode: op1  2-  0<
  225.     IF
  226.         op1 false buildRegMask drop
  227.         op2 getop
  228.         op2 modesize ++> len
  229.     ELSE
  230.         op2 getop
  231.         op1 modesize ++> len
  232.         THEN
  233.     len
  234.     #tib @ -> pos            \ Force input of a new line.
  235. ;M
  236.  
  237. ;CLASS
  238.  
  239. \ TYPE21 - UNLK
  240. :CLASS type21 super(  machinst  )
  241.  
  242. :M BUILD:
  243.     op1 getOp
  244.     get: bytecode
  245.     reg: op1 or
  246.     w,
  247. ;M
  248.  
  249. :M LENGTH:
  250.     op1 getOp
  251.     op1 get: srcMask check
  252.     1
  253. ;M
  254.  
  255. ;CLASS
  256.  
  257. \ TYPE22 - ADDX, SUBX, CMPM
  258. :CLASS type22 super(  machinst  )
  259.  
  260. :M BUILD:       { \ work -- }
  261.     op1 getOp
  262.     op2 getOp
  263.     get: bytecode -> work
  264.     reg: op1 work or -> work
  265.     opFmt 6 << work or -> work
  266.     reg: op2 9 << work or -> work
  267.     mode: op1 4 =
  268.     IF
  269.         8 work or -> work
  270.     THEN
  271.     work w,
  272. ;M
  273.  
  274. :M LENGTH:      { \ len -- len }
  275.     op1 getOp
  276.     op1 get: srcMask check
  277.     op2 getOp
  278.     op2 get: dstMask check
  279.     mode: op1 mode: op2 = not 
  280.     IF
  281.         207 asmError
  282.     THEN
  283.     1 -> len
  284.     op1 modesize ++> len
  285.     op2 modesize ++> len
  286.     len
  287. ;M
  288.  
  289. ;CLASS
  290.  
  291. :CLASS type23 super(  machinst  )        \ Pseudo-ops
  292.  
  293. :M LENGTH:
  294.     get: srcmask        \ we use the srcmask field for the op
  295.     SELECT{
  296.         0    IS{    #tib @ -> pos        }END    \ comment
  297.         1    IS{    release: symtab        }END    \ LOC
  298.     DEFAULT{
  299.     }SELECT
  300.     0
  301. ;M
  302.  
  303. :M BUILD:
  304.     get: srcmask
  305.     SELECT{
  306.         0    IS{    #tib @ -> pos        }END
  307.         1    IS{                }END
  308.     DEFAULT{
  309.     }SELECT
  310. ;M
  311.  
  312. ;CLASS
  313.  
  314. :CLASS type24 super(  machinst  )        \ Call
  315.  
  316. :M LENGTH:
  317.     1                               \ Length fixed - mrh
  318.     #tib @ -> pos
  319. ;M
  320. :M BUILD:
  321.     nextToken drop 
  322.     get: token  >r  here r cmove  here r> AsmCall
  323. ;M
  324.  
  325. ;CLASS
  326.  
  327. \ TYPE26 - Sized instruction with single ea operand, e.g. NOT, CLR, NEG
  328.  
  329. :CLASS type26 super(  machinst  )
  330.  
  331. :M LENGTH:
  332.     op1 getOp
  333.     op1 get: srcMask check
  334.     1 op1 modesize +
  335. ;M
  336.  
  337. :M BUILD:
  338.     op1 getOp
  339.     get: bytecode ea: op1 or
  340.     opFmt 6 << or w,
  341.     op1 compidxmode
  342. ;M
  343.  
  344. ;CLASS
  345.  
  346.  
  347. \ CLASS27 - STOP
  348.  
  349. :CLASS type27 super(  machinst  )
  350.  
  351. :M LENGTH:
  352.     op1 getOp
  353.     op1 get: srcMask check
  354.     2
  355. ;M
  356.  
  357. :M BUILD:
  358.     op1 getOp
  359.     get: bytecode w,
  360.     value: op1 w,
  361. ;M
  362.  
  363. ;CLASS
  364.  
  365. \ TYPE28 - PUSH and POP - synonyms for MOVE to and from the stack.
  366.  
  367. :CLASS TYPE28  super(  machinst  )
  368.  
  369. :M BUILD:
  370.     op1 getOp
  371.     get: bytecode  dup  $ 20  <
  372.     IF  ( POP )
  373.         reg: op1  9 <<  mode: op1  7 min  6 <<  or
  374.     ELSE
  375.         ea: op1
  376.     THEN  or
  377.     opFmt  moveSize  or   w,
  378.     op1 compIdxMode
  379. ;M
  380.  
  381. :M LENGTH:
  382.     op1 getOp
  383.     op1 get: srcMask  check
  384.     op1 modeSize  1+
  385. ;M
  386.  
  387. ;CLASS
  388.  
  389.  
  390. \ TYPE29 - DC.  Only numbers allowed, e.g.  dc.w  99,$200
  391.  
  392. :CLASS TYPE29    super(    machinst  )
  393.  
  394. :M BUILD:  { \ cnt -- }
  395.     getFormat  0 -> cnt  nextToken drop
  396.     BEGIN                    \ Loop over items
  397.         get: token  >num  val" number is"
  398.         opFmt
  399.         NIF    c,
  400.         ELSE    opFmt 1 =  IF   w,  ELSE  ,  THEN
  401.         THEN
  402.         nextToken drop  get: token  " ,"  s=
  403.     WHILE
  404.         nextToken drop
  405.     REPEAT
  406.     dp 1 and IF  0 c,  THEN
  407. ;M
  408.  
  409. :M LENGTH:  { \ cnt -- #wds }
  410.     getFormat  0 -> cnt  nextToken drop
  411.     BEGIN                    \ Loop over items
  412.         get: token >num  drop  1 ++> cnt
  413.         nextToken drop  get: token  " ,"  s=
  414.     WHILE
  415.         nextToken drop
  416.     REPEAT
  417.     opFmt Bfmt = IF  cnt align 2/  EXIT  THEN
  418.     opFmt cnt *
  419. ;m
  420.  
  421. ;CLASS
  422.  
  423.  
  424. \    ========  Floating point coprocessor classes  ==========
  425.  
  426. operand  K-FACTOR
  427.  
  428. : >SSPEC    \ ( format -- sspec )
  429.     SELECT{
  430.         Bfmt    is{  6    }end
  431.         Wfmt    is{  4    }end
  432.         Lfmt    is{  0    }end
  433.         Sfmt    is{  1    }end
  434.         Dfmt    is{  5    }end
  435.         Xfmt    is{  2    }end
  436.         Pfmt    is{  3    }end
  437.         DEFAULT{
  438.     }SELECT  ;
  439.  
  440.  
  441. \ FPMONADIC - normal FP monadic instructions, e.g. FNEG.
  442.  
  443. :class    FPMONADIC    super{ machinst }
  444.  
  445. :m BUILD:  { \ wd0 wd1 -- }
  446.     get: bytecode -> wd0
  447.     get: dstMask  -> wd1        \ We use the dstMask field for the
  448.                     \  opcode extension
  449.     op1 getop
  450.     wd1  $ 3A =            \ Is it FTST?
  451.     NIF                \ No - may be 2 operands.
  452.         nextToken drop
  453.         " ,"  get: token  s=
  454.         IF            \ 2-operand format
  455.             op2 getop
  456.             reg: op2
  457.         ELSE            \ 1-operand format
  458.             reg: op1
  459.         THEN
  460.     ELSE                \ FTST - can only have 1 operand
  461.         reg: op1
  462.     THEN
  463.       7 <<  or> wd1            \ Set dest reg field
  464.     mode: op1  FPnMode =
  465.     IF
  466.         reg: op1  10 <<  or> wd1
  467.     ELSE
  468.         $ 4000  or> wd1            \ Set r/m bit
  469.         opFmt >sspec  10 <<  or> wd1    \ Source specifier field
  470.         ea: op1  or> wd0
  471.     THEN
  472.     wd0 w,  wd1 w,
  473.     op1 compIdxMode
  474. ;m
  475.  
  476. :m LENGTH:
  477.     op1 getop  nextToken drop
  478.     " ,"  get: token  s=
  479.     IF            \ 2-operand format
  480.         op2 getop
  481.         mode: op2
  482.     ELSE
  483.         mode: op1
  484.     THEN
  485.     FPnMode <> IF  245 asmError  THEN    \ Dest must be FPn
  486.     2  op1 modesize +
  487. ;m
  488.  
  489. ;class
  490.  
  491.  
  492. :class    FPDYADIC    super{ machinst }
  493.  
  494. private
  495.  
  496. :m (BLD):  { \ wd0 wd1 -- }
  497.     get: bytecode -> wd0
  498.     get: dstMask  -> wd1        \ We use the dstMask field for the
  499.                     \  opcode extension
  500.     reg: op2  7 <<  or> wd1        \ Set dest reg field
  501.     mode: op1  FPnMode =
  502.     IF
  503.         reg: op1  10 <<  or> wd1
  504.     ELSE
  505.         $ 4000  or> wd1            \ Set r/m bit
  506.         opFmt >sspec  10 <<  or> wd1    \ Source specifier field
  507.         ea: op1  or> wd0
  508.     THEN
  509.     wd0 w,  wd1 w,
  510.     op1 compIdxMode
  511. ;m
  512. public
  513.  
  514. :m BUILD:    op1 getop  op2 getop  (bld): self  ;m
  515.  
  516. :m LENGTH:
  517.     op1 getop  op2 getop
  518.     mode: op2  FPnMode <> IF  245 asmError  THEN    \ Dest must be FPn
  519.     2  op1 modesize +
  520. ;m
  521.  
  522. ;class
  523.  
  524.  
  525. :class    FMOVE    super{ FPdyadic }
  526.  
  527.     \ This isn't a whole lot better than MOVE!
  528.  
  529. private
  530.  
  531. :m MoveFPctlReg:  { to? \ wd0 wd1 reg -- }
  532.     get: bytecode  -> wd0
  533.     to? IF
  534.         $ 8000  -> wd1
  535.         ea: op1  or> wd0
  536.         reg: op2
  537.     ELSE
  538.         $ A000  -> wd1
  539.         ea: op2  or> wd0
  540.         reg: op1
  541.     THEN
  542.     10 +  1 swap  <<  or> wd1
  543.     wd0 w,  wd1 w,
  544.     to? IF op1 ELSE op2 THEN  compIdxMode  ;m
  545.  
  546. public
  547.  
  548. :m BUILD:  { \ wd0 wd1 kfact -- }
  549.     op1 getop  op2 getop
  550.     mode: op2  FPnMode =
  551.     IF  (bld): super  EXIT  THEN    \ If dest is FPn, same as normal
  552.                     \  dyadic op.
  553.     mode: op1  FPctlRegMode =
  554.     IF  false moveFPctlReg: self  EXIT  THEN
  555.     mode: op2  FPctlRegMode =
  556.     IF  true moveFPctlReg: self  EXIT  THEN
  557.  
  558.     mode: op1  FPnMode  <>  IF  255 asmerror  THEN    \ Wrong operand type
  559.  
  560.     get: bytecode -> wd0        \ Source is FPn
  561.     $ 6000  -> wd1  0 -> kfact
  562.     opFmt Pfmt =
  563.     IF                \ P format.  This is special!
  564.         nextToken drop
  565.         1st: token  & {  <> IF  203 asmerror  THEN
  566.         op3 getOp
  567.         mode: op3  DnMode =
  568.         IF
  569.             reg: op3  4 <<  or> wd1
  570.             $ 1C00  or> wd1        \ Dest format field
  571.         ELSE
  572.             mode: op3  immedMode <> IF  245 asmerror  THEN
  573.             value: op3  or> wd1
  574.             $ 0C00  or> wd1        \ Dest format field
  575.         THEN
  576.     ELSE
  577.         opFmt >sspec  10 <<  or> wd1    \ Dest format field
  578.     THEN
  579.     reg: op1  7 <<  or> wd1        \ Set source reg field
  580.     ea: op2  or> wd0
  581.     wd0 w,  wd1 w,
  582.     op2 compIdxMode
  583. ;m
  584.  
  585. :m LENGTH:
  586.     op1 getop  op2 getop
  587.     mode: op1  FPctlRegMode =
  588.     IF
  589.         op2  $ 71FF  check
  590.         op2 modesize  2+  EXIT
  591.     THEN
  592.     mode: op2  FPctlRegMode =
  593.     IF
  594.         op1  $ 7FFF  check
  595.         op1 modesize  2+  EXIT
  596.     THEN
  597.     mode: op2  FPnMode =
  598.     IF
  599.         op1 modesize  2+
  600.     ELSE
  601.         mode: op1  FPnMode <> IF  255 asmError  THEN
  602.         op2 modesize  2+
  603.     THEN
  604. ;m
  605.  
  606. ;class
  607.  
  608.     0    value    REGMASK
  609.  
  610. :class    FMOVEM    super{ machinst }
  611.  
  612. :m BUILD:  { \ drFlag wd0 wd1 CRflag mode -- }
  613.     get: bytecode -> wd0
  614.     get: dstMask  -> wd1
  615.     false -> CRflag  0 -> mode  0 -> regMask
  616.     op1 getOp
  617.     mode: op1  dup  FPnMode =  over FPctlRegMode =  or
  618.     swap DnMode = or
  619.     IF            \ Register to memory
  620.         1 -> drFlag
  621.         mode: op1  DnMode =
  622.         IF
  623.             1 -> mode
  624.             reg: op1  -> regMask
  625.         ELSE
  626.             mode: op1  FPctlRegMode =  -> CRflag
  627.             op1 true buildRegMask  -> regMask
  628.         THEN
  629.         op2 getOp
  630.         mode: op2  -(An)Mode <>  2 and  or> mode
  631.         ea: op2
  632.     ELSE            \ Memory to register
  633.         0 -> drFlag
  634.         nextToken drop
  635.         op2 getOp
  636.         mode: op2  DnMode =
  637.         IF
  638.             3 -> mode
  639.             reg: op2  -> regMask
  640.         ELSE
  641.             2 -> mode
  642.             op2 true buildRegMask -> regMask
  643.             mode: op2  FPctlRegMode =  -> CRflag
  644.         THEN
  645.         ea: op1
  646.     THEN
  647.     ( ea in stack )  or> wd0
  648.     drFlag    13 <<  or> wd1
  649.     mode    11 <<  or> wd1
  650.     CRflag
  651.     NIF
  652.         mode: op2  -(An)mode <>  mode 1 and  0=  and
  653.                 \ i.e. not predecrement, and static reg list.
  654.                 \ NOTE mask is reversed compared with MOVEM!
  655.         IF  regMask revMask  8 >>  -> regMask  THEN
  656.     THEN
  657.     regMask  or> wd1
  658.     wd0 w,  wd1 w,
  659.     op1 compidxmode  op2 compidxmode
  660. ;m
  661.  
  662. :m LENGTH:
  663.     op1 getop
  664.     mode: op1  FPnMode =
  665.     IF
  666.         op1 true buildRegMask drop
  667.         op2 getop
  668.         2  op2 modesize +
  669.     ELSE
  670.         op2 getop
  671.         2  op1 modesize +
  672.         THEN
  673.     #tib @ -> pos            \ Force input of a new line.
  674. ;m
  675.  
  676. ;class
  677.  
  678.  
  679. :class    FBcc    super{ machinst }
  680.  
  681. :m BUILD:  { \ wd -- }
  682.     get: bytecode  -> wd
  683.     op1 getOp
  684.     op1 abs: operand  dup  NIF  245 asmError  THEN    \ wrong mode
  685.     here 2+ -
  686.     opFmt Wfmt =
  687.     IF    wd w,  250 wordChk  w,
  688.     ELSE    $ 40  or> wd  wd w,  ,
  689.     THEN
  690. ;m
  691.  
  692. :m LENGTH:
  693.     op1 getOp
  694.     op1 get: srcMask check
  695.     opFmt Wfmt = IF  2  ELSE  3  THEN
  696. ;m
  697.  
  698. ;class
  699.  
  700.  
  701. :class  FDBcc    super{ machinst }
  702.  
  703. :m BUILD:  { \ wd0 wd1 -- }
  704.         \ We have the 2 opcode words combined in bytecode
  705.         \ as AsmCodes is easier to set up that way.  Now we
  706.         \ must separate them.
  707.     get: bytecode  dup  -> wd0  -> wd1
  708.     $ FFE0    and> wd0  8 or> wd0
  709.     $ 1F    and> wd1
  710.     op1 getOp  op2 getOp
  711.     reg: op1  or> wd0
  712.     wd0 w,  wd1 w,
  713.     op2 abs: operand  here -  248 wordChk  w,
  714. ;m
  715.  
  716. :m LENGTH:
  717.     op1 getOp
  718.     op1 get: srcMask check
  719.     op2 getOp
  720.     op2 get: dstMask check
  721.     3
  722. ;m
  723.  
  724. ;class
  725.  
  726.  
  727. :class    FScc    super{ machinst }
  728.  
  729. :m BUILD:  { \ wd0 wd1 -- }
  730.     get: bytecode  dup  -> wd0  -> wd1
  731.     $ FFC0    and> wd0  $ 40  or> wd0
  732.     $ 1F    and> wd1
  733.     op1 getOp  ea: op1  or> wd0
  734.     wd0 w,  wd1 w,
  735.     op1 compIdxMode
  736. ;m
  737.  
  738. :m LENGTH:
  739.     op1 getOp
  740.     op1 get: srcMask  check
  741.     2  op1 modeSize  +
  742. ;m
  743.  
  744. ;class
  745.  
  746.  
  747. :class    FTRAPcc  super{ machinst }
  748.  
  749. :m BUILD:  { \ wd0 wd1 -- }
  750.     get: bytecode  dup  -> wd0  -> wd1
  751.     $ FFC0    and> wd0  $ 38  or> wd0
  752.     $ 1F    and> wd1
  753.     opFmt Wfmt =  opFmt Lfmt =  or
  754.     IF
  755.         op1 getOp
  756.         opFmt Wfmt =
  757.         IF
  758.             2 or> wd0  wd0 w,  wd1 w,
  759.             value: op1  248 wordChk  w,
  760.         ELSE
  761.             3 or> wd0  wd0 w,  wd1 w,
  762.             value: op1  ,
  763.         THEN
  764.     ELSE
  765.         4 or> wd0  wd0 w,  wd1 w,
  766.     THEN
  767. ;m
  768.  
  769. :m LENGTH:
  770.     opFmt Wfmt =  opFmt Lfmt =  or
  771.     IF
  772.         op1 getOp  op1  get: srcmask  check
  773.         opFmt Wfmt = IF  3  ELSE  4  THEN  EXIT
  774.     THEN
  775.     2
  776. ;m
  777.  
  778. ;class
  779.  
  780.  
  781. :class    FMOVECR  super{ machinst }
  782.  
  783. :m BUILD:  { \ wd0 wd1 -- }
  784.     get: bytecode  -> wd0  get: dstMask  -> wd1
  785.     op1 getOp  op2 getOp
  786.     value: op1  $ 7F and    or> wd1
  787.     reg: op2   7 <<        or> wd1
  788.     wd0 w,  wd1 w,
  789. ;m
  790.  
  791. :m LENGTH:
  792.     op1 getOp  op2 getOp
  793.     op1  get: srcMask  check
  794.     op2  $ 8000  check        \ Must be FPn
  795.     2
  796. ;m
  797.  
  798. ;class
  799.  
  800.  
  801. :class    FNOP    super{ machinst }
  802.  
  803. :m BUILD:
  804.     get: bytecode  w,  get: dstMask  w,  ;m
  805.  
  806. :m LENGTH:    2  ;m
  807.  
  808. ;class
  809.  
  810. :class    FSINCOS  super{ machinst }
  811.  
  812. :m BUILD:  { \ wd0 wd1 -- }
  813.     op1 getop  op3 getop  nextToken drop  op2 getop
  814.     get: bytecode -> wd0
  815.     get: dstMask  -> wd1
  816.     reg: op2  7 <<    or> wd1
  817.     reg: op3    or> wd1
  818.     mode: op1  FPnMode =
  819.     IF
  820.         reg: op1  10 <<  or> wd1
  821.     ELSE
  822.         $ 4000  or> wd1            \ Set r/m bit
  823.         opFmt >sspec  10 <<  or> wd1    \ Source specifier field
  824.         ea: op1  or> wd0
  825.     THEN
  826.     wd0 w,  wd1 w,
  827.     op1 compIdxMode
  828. ;m
  829.  
  830.  
  831. :m LENGTH:
  832.     op1 getop  op3 getop
  833.     nextToken drop
  834.     1st: token  & :  <> IF  203 asmerror  THEN    \ Bad operand
  835.     op2 getop
  836.     op2  $ 8000 check  op3  $ 8000 check    \ Both dests must be FPn
  837.     op1 modesize  2+
  838. ;m
  839.  
  840. ;class
  841.